package main

import (
	"encoding/json"
	"fmt"
	"net/url"
	"strconv"
	"strings"
	"time"

	"github.com/spf13/cast"
)

func main() {
	// 假设时间戳是秒级的（int64）
	timestamp := int64(1729152011) // 2024-10-18 00:00:00 UTC

	// 转换为 time.Time（UTC）
	t := time.Unix(timestamp, 0)
	fmt.Println(t)
	// 打印本地时间
	fmt.Println("本地时间:", t.Local())

	// 打印 UTC 时间
	fmt.Println("UTC时间:", t.UTC())

	RemindAt := time.UnixMilli(1750070700).UTC()
	fmt.Println(RemindAt)

	aemindAt := time.Unix(int64(1750070700), 0).Local()
	fmt.Println(aemindAt)

	a := []string{"111", "2"}
	fmt.Println(len(a))

	b := []string{"111"}
	fmt.Println(cast.ToInt(b[0]))

	remindAt, err := time.Parse(time.RFC3339, "2025-06-18T00:00:00Z")
	fmt.Println(remindAt, err)
	remindAt1 := remindAt.Unix()
	fmt.Println(remindAt1)

	as := "批量0620077777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
	if len([]rune(as)) > 20 {
		fmt.Println("长度超标")
	}
	fmt.Println(len([]rune(as)))

	itemID := strconv.FormatInt(1111111111112323232, 10)
	fmt.Println(itemID)

	aa := int64(1750316400)
	fmt.Println(aa)
	a1 := time.UnixMilli(aa).UTC()
	fmt.Println(a1.UnixMilli(), time.Now().UnixMilli())

	type Range struct {
		Row      int `json:"row"`
		Col      int `json:"col"`
		RowCount int `json:"rowCount"`
		ColCount int `json:"colCount"`
	}

	type PositionInfo struct {
		SheetId string  `json:"sheetId"`
		Ranges  []Range `json:"ranges"`
	}

	type Payload struct {
		PositionInfo PositionInfo `json:"positionInfo"`
	}
	jsonStr := `{
		"positionInfo": {
			"sheetId": "XEkHX",
			"ranges": [
				{"row": 4, "col": 14, "rowCount": 22, "colCount": 4},
				{"row": 4, "col": 10, "rowCount": 22, "colCount": 4},
				{"row": 3, "col": 12, "rowCount": 1, "colCount": 6},
				{"row": 3, "col": 10, "rowCount": 1, "colCount": 2}
			]
		}
	}`
	var payload Payload
	err = json.Unmarshal([]byte(jsonStr), &payload)
	if err != nil {
		fmt.Println(111, err)
	}

	var parts []string
	for _, r := range payload.PositionInfo.Ranges {
		part := fmt.Sprintf("%d_%d_%d_%d", r.Row, r.Col, r.RowCount, r.ColCount)
		parts = append(parts, part)
	}

	result := fmt.Sprintf("#remind__%s__%s", payload.PositionInfo.SheetId, strings.Join(parts, "__"))
	fmt.Println(result)

	t1 := time.Now().In(time.UTC).Format(time.RFC3339)
	fmt.Println(t1)
	t2 := time.Now().In(time.UTC).Unix()
	fmt.Println(t2)

	t3 := time.Unix(t2, 0).UTC().Format(time.RFC3339)
	fmt.Println(t3)
	getPath()
}

func getPath() {
	//channel := "" // 假设有一个 channel
	//
	//// 构造 path
	//path := "/fill"
	//if channel != "" {
	//	// 使用 url.Values 来构造 ?channel=xxx
	//	q := url.Values{}
	//	q.Set("channel", channel)
	//	path = path + "?" + q.Encode()
	//}
	//
	//ss := url.QueryEscape(path)
	//fmt.Println(ss)
	// 调用 generateUrl
	//map[string]string{
	//	"type":        "form",
	//	"fileGuid":    guid,
	//	"path":        url.QueryEscape(path),
	//	"sharingType": "formFill",
	//}
	//if err != nil {
	//	panic(err)
	//}
	base := "https://example.com/form"
	startParams := map[string]string{
		"user":  "alice",
		"token": "xyz123",
	}
	startParamsKey := "startParams"

	link, err := generateUrl(base, startParams, startParamsKey)
	if err != nil {
		panic(err)
	}

	fmt.Println("生成的链接:", link)
}

// 模拟 encodeStartParams，把参数序列化成字符串
func encodeStartParams(params map[string]string) string {
	// 这里简单拼接，也可以用 JSON 或其他方式
	values := url.Values{}
	for k, v := range params {
		values.Set(k, v)
	}
	return values.Encode()
}

// generateUrl 模拟生成带参数的 URL
func generateUrl(base string, params map[string]string, startParamsKey string) (string, error) {
	// 解析基础 URL
	u, err := url.Parse(base)
	if err != nil {
		return "", err
	}

	// 获取已有的 query 参数
	q := u.Query()

	// 设置新的参数
	q.Set(startParamsKey, encodeStartParams(params))

	// 回写到 URL
	u.RawQuery = q.Encode()

	return u.String(), nil
}
